package com.example.translateappjava.Utils; // 你的包名

import android.app.Activity;
import android.graphics.Bitmap;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;

import com.example.translateappjava.Fragment.HomeFragment; // 你可能不需要直接引用HomeFragment实例了
import com.example.translateappjava.Listener.LoadingProgressListener; // 确认路径正确
import com.example.translateappjava.Service.AliyunAPI.AliyunAPIHelper;
import com.example.translateappjava.Service.DiabetesFoodAdvisor;
import com.example.translateappjava.Service.Doubao.DoubaoVisionHelper;
import com.example.translateappjava.Service.YOLOAPI.ImageUploader; // 你的YOLO上传类
// import com.example.translateappjava.Utils.ImageData; // ImageData应该在同一个包或正确导入

import java.util.ArrayList;
import java.util.concurrent.atomic.AtomicInteger;

public class ImageRecognitionManager {

    // private HomeFragment homeFragment; // 尽量避免直接持有Fragment实例，通过Listener回调
    private Activity activity;
    private DoubaoVisionHelper doubaoVisionHelper;
    private ArrayList<ImageData> imageDataList; // 这个是处理过程中的列表
    private AtomicInteger remainingRequests; // 跟踪API请求数量
    private RecognitionCompleteListener recognitionCompleteListener;
    private DiabetesFoodAdvisor diabetesFoodAdvisor;
    private LoadingProgressListener loadingProgressListener; // 新的加载进度监听器

    // 阿里云和豆包的Helper实例，如果它们在HomeFragment中作为监听器回调，则不需要在这里重复创建
    // 但你的代码显示你在startAliyunRecognition中重新创建了AliyunAPIHelper并设置了新的listener，这是可以的。
    // private AliyunAPIHelper aliyunHelperInstance; // 可以考虑在构造函数中初始化一次

    public interface RecognitionCompleteListener {
        void onRecognitionComplete(ArrayList<ImageData> imageDataList); // 这个是识别完成后的回调
    }

    public ImageRecognitionManager(HomeFragment fragment, Activity activity) { // fragment 主要用于设置API Listener
        // this.homeFragment = fragment; // 如果不再直接调用fragment.hideLoadingUI()，可以考虑移除
        this.activity = activity;

        // 初始化DoubaoVisionHelper，它会将回调给HomeFragment
        this.doubaoVisionHelper = new DoubaoVisionHelper(activity);
        // HomeFragment 需要实现 DoubaoVisionHelper.DoubaoVisionListener
        if (fragment instanceof DoubaoVisionHelper.DoubaoVisionListener) {
            this.doubaoVisionHelper.setDoubaoVisionListener((DoubaoVisionHelper.DoubaoVisionListener) fragment);
        } else {
            Log.e("ImageRecognitionManager", "HomeFragment must implement DoubaoVisionListener");
            // 可以抛出异常或进行错误处理
        }

        // 初始化 DiabetesFoodAdvisor，并传递 LoadingProgressListener
        this.diabetesFoodAdvisor = new DiabetesFoodAdvisor(activity);
    }

    public void setLoadingProgressListener(LoadingProgressListener listener) {
        this.loadingProgressListener = listener;
        if (this.diabetesFoodAdvisor != null) {
            this.diabetesFoodAdvisor.setLoadingProgressListener(listener); // 传递给下游
        }
    }

    public void setRecognitionCompleteListener(RecognitionCompleteListener listener) {
        this.recognitionCompleteListener = listener;
    }

    public void processImage(Bitmap bitmap) {
        // 图像处理开始时，通过 HomeFragment 更新UI (HomeFragment.onImageCaptured -> onProcessingStart)
        // loadingProgressListener.onProcessingStart("正在准备图片..."); // 这行已在HomeFragment中调用

        if (loadingProgressListener != null) {
            loadingProgressListener.onProgressUpdate("上传图片进行分割...");
        }

        ImageUploader uploader = new ImageUploader(); // 你的YOLO上传和分割类
        uploader.uploadImage(bitmap, new ImageUploader.ImageUploadCallback() {
            @Override
            public void onUploadComplete(ArrayList<Bitmap> bitmaps, ArrayList<byte[]> bytes, ArrayList<String> URLs) {
                Log.v("ImageRecognitionManager", "YOLO分割完成，得到图像块数量: " + bitmaps.size());

                if (bitmaps.isEmpty()) {
                    Log.w("ImageRecognitionManager", "YOLO未分割出任何图像块。");
                    Toast.makeText(activity, "未能从图片中检测到物体。", Toast.LENGTH_SHORT).show();
                    if (loadingProgressListener != null) {
                        Log.i("onProcessingComplete", "YOLO未分割出任何图像块");
                        loadingProgressListener.onProcessingComplete(); // 结束加载
                    }
                    return;
                }

                if (loadingProgressListener != null) {
                    loadingProgressListener.onProgressUpdate("分割完成，开始识别图像块...", "共 " + bitmaps.size() + " 个");
                }

                remainingRequests = new AtomicInteger(bitmaps.size());
                imageDataList = new ArrayList<>();

                for (int i = 0; i < bitmaps.size(); i++) {
                    // 注意：你的ImageData构造函数是 (Bitmap, String recognitionResult, String gptResponse, boolean isSafe)
                    // 初始时 gptResponse 和 isSafe 可以设为默认值或null
                    ImageData imageData = new ImageData(bitmaps.get(i), "待识别", null, false);
                    imageData.setImageURL(URLs.get(i)); // 假设你有一个setImageURL方法
                    imageDataList.add(imageData);
                }
                startAliyunRecognition(bytes);
            }

            @Override
            public void onUploadFailed(Exception e) {
                Log.e("ImageRecognitionManager", "YOLO图片上传/分割失败: " + e.getMessage());
                Toast.makeText(activity, "图片分割处理失败: " + e.getMessage(), Toast.LENGTH_SHORT).show();
                if (loadingProgressListener != null) {
                    loadingProgressListener.onProcessingError("图片分割失败"); // 结束加载并提示错误
                }
            }
        });
    }

    private void startAliyunRecognition(ArrayList<byte[]> bytes) {
        if (bytes.isEmpty()) {
            Log.w("ImageRecognitionManager", "没有图像数据可供阿里云识别。");
            // 这种情况下，可能YOLO分割了，但没有返回有效的byte[]
            // 需要决定如何处理，是直接报错还是尝试豆包，或结束
            if (remainingRequests.get() == 0) { // 确保没有其他请求
                processAllRecognitionComplete();
            }
            return;
        }

        // HomeFragment 需要实现 AliyunAPIHelper.AliyunAPIListener
        // AliyunAPIHelper的listener直接设置为调用ImageRecognitionManager内部的方法
        AliyunAPIHelper aliyunAPIHelper = new AliyunAPIHelper(activity);
        aliyunAPIHelper.setAliyunAPIListener(new AliyunAPIHelper.AliyunAPIListener() {
            @Override
            public void AliyunAPIResponse(String response, int index) {
                // 这里的index是阿里云API调用时传入的，对应bytes列表的索引
                handleAliyunAPIResponse(response, index);
            }

            @Override
            public void AliyunAPIError(String message /*, int index  // 如果阿里云错误回调也给index会更好*/) {
                // 假设阿里云的错误是针对所有请求或无法定位到具体index
                // 如果能定位到index，则可以只标记对应imageData为失败
                Log.e("ImageRecognitionManager", "阿里云API错误(整体): " + message);
                // 暂时认为阿里云API错误是致命的，影响所有未完成的识别
                // 你可以根据实际情况调整，比如只将当前所有未完成的请求标记为失败
                // 标记所有剩余的请求为失败，并尝试完成流程
                int remaining = remainingRequests.get();
                for (int i = 0; i < remaining; i++) {
                    if (remainingRequests.decrementAndGet() == 0) {
                        break;
                    }
                }
                if (loadingProgressListener != null) {
                    loadingProgressListener.onProcessingError("阿里云识别服务出错");
                } else { // fallback if listener is null
                    Toast.makeText(activity, "阿里云识别出错", Toast.LENGTH_SHORT).show();
                }
                processAllRecognitionComplete(); // 尝试处理已有的结果（可能为空）
            }
        });

        for (int i = 0; i < bytes.size(); i++) {
            if (loadingProgressListener != null) {
                loadingProgressListener.onProgressUpdate("正在识别物体 (" + (imageDataList.size() - remainingRequests.get() + i +1) + "/" + imageDataList.size() + ")");
            }
            aliyunAPIHelper.AliyunAPIFilePathRequest(bytes.get(i), i); // 传递索引i
        }
    }

    public void handleAliyunAPIResponse(String response, int index) {
        Log.d("ImageRecognitionManager", "阿里云响应 (索引 " + index + "): " + response);
        if (index < 0 || index >= imageDataList.size()) {
            Log.e("ImageRecognitionManager", "阿里云响应索引越界: " + index);
            if (remainingRequests.decrementAndGet() == 0) {
                processAllRecognitionComplete();
            }
            return;
        }

        if ("非菜".equals(response)) {
            Log.i("ImageRecognitionManager", "阿里云识别为'非菜' (索引 " + index + "), 转豆包二次识别");
            if (loadingProgressListener != null) {
                loadingProgressListener.onProgressUpdate("物体 " + (index + 1) + " 初步识别为非菜，尝试精细识别...");
            }
            Bitmap bitmapToAnalyze = imageDataList.get(index).getImage(); // 你的ImageData类需要有getImage()方法
            if (doubaoVisionHelper != null && bitmapToAnalyze != null) {
                doubaoVisionHelper.analyzeFood(bitmapToAnalyze, index); // 豆包的回调会处理remainingRequests
            } else {
                Log.w("ImageRecognitionManager", "无法进行二次识别 (索引 " + index + ")");
                imageDataList.get(index).setRecognitionResult("识别失败(非菜)"); // 标记为识别失败
                if (remainingRequests.decrementAndGet() == 0) {
                    processAllRecognitionComplete();
                }
            }
        } else {
            imageDataList.get(index).setRecognitionResult(response);
            if (loadingProgressListener != null) {
                loadingProgressListener.onProgressUpdate("物体 " + (index + 1) + " 识别为: " + response);
            }
            if (remainingRequests.decrementAndGet() == 0) {
                processAllRecognitionComplete();
            }
        }
    }
    public void handleAliyunAPIError(String message) {
        Log.e("ImageRecognitionManager", "Aliyun API Error: " + message);

        if (remainingRequests != null && remainingRequests.decrementAndGet() == 0) {
            processAllRecognitionComplete();
        }
    }
    // HomeFragment 中实现的 DoubaoVisionListener 会调用这两个方法
    // 确保 HomeFragment 将这些调用委托给 ImageRecognitionManager 的实例
    public void handleDoubaoVisionResponse(String response, int index) {
        Log.d("ImageRecognitionManager", "豆包二次识别响应 (索引 " + index + "): " + response);
        activity.runOnUiThread(() -> { // 确保在主线程更新UI相关的计数和状态
            if (index < 0 || index >= imageDataList.size()) {
                Log.e("ImageRecognitionManager", "豆包响应索引越界: " + index);
                if (remainingRequests.decrementAndGet() == 0) { // 即使越界也要减计数
                    processAllRecognitionComplete();
                }
                return;
            }

            if (response.contains("无食物") || response.contains("没有食物") || response.contains("非食物")) {
                imageDataList.get(index).setRecognitionResult("非食物"); // 标记结果
                Toast.makeText(activity, "物体 " + (index + 1) + " 精细识别结果：非食物", Toast.LENGTH_SHORT).show();
            } else {
                imageDataList.get(index).setRecognitionResult(response);
                if (loadingProgressListener != null) {
                    loadingProgressListener.onProgressUpdate("物体 " + (index + 1) + " 精细识别为: " + response);
                }
            }

            if (remainingRequests.decrementAndGet() == 0) {
                processAllRecognitionComplete();
            }
        });
    }

    public void handleDoubaoVisionError(String error, int index) {
        Log.e("ImageRecognitionManager", "豆包二次识别错误 (索引 " + index + "): " + error);
        activity.runOnUiThread(() -> {
            if (index >= 0 && index < imageDataList.size()) {
                imageDataList.get(index).setRecognitionResult("识别失败(豆包)"); // 标记结果
            }
            Toast.makeText(activity, "物体 " + (index + 1) + " 精细识别失败", Toast.LENGTH_SHORT).show();
            if (remainingRequests.decrementAndGet() == 0) {
                processAllRecognitionComplete();
            }
        });
    }

    private void processAllRecognitionComplete() {
        Log.d("ImageRecognitionManager", "所有识别请求（阿里云/豆包）处理完毕。");
        // 此时，所有初步识别（包括可能的二次识别）都已完成
        // imageDataList 中的 recognitionResult 字段应该都已填充（成功或失败标记）

        // 不再在这里隐藏UI，转交控制权给 DiabetesFoodAdvisor，它会在GPT分析完成后隐藏
        // if (loadingProgressListener != null) {
        // loadingProgressListener.onProgressUpdate("识别完成，准备分析食物...");
        // }

        if (imageDataList != null && !imageDataList.isEmpty()) {
            boolean hasValidResultForGpt = false;
            for (ImageData data : imageDataList) {
                if (isValidRecognitionResult(data.getRecognitionResult())) {
                    hasValidResultForGpt = true;
                    break;
                }
            }

            if (hasValidResultForGpt) {
                if (loadingProgressListener != null) {
                    // DiabetesFoodAdvisor会接手更新进度
                    loadingProgressListener.onProgressUpdate("识别完成，开始营养分析...");
                }
                // DiabetesFoodAdvisor 的构造函数里已经设置了loadingProgressListener
                diabetesFoodAdvisor.processFoodRecognitionResult(new ArrayList<>(imageDataList)); // 传递副本
            } else {
                Log.w("ImageRecognitionManager", "没有有效的识别结果可供GPT分析。");
                Toast.makeText(activity, "未能识别出任何有效食物。", Toast.LENGTH_LONG).show();
                if (loadingProgressListener != null) {
                    Log.i("onProcessingComplete", "没有东西给GPT，直接完成");
                    loadingProgressListener.onProcessingComplete(); // 没有东西给GPT，直接完成
                }
            }
            // 不论是否有有效结果给GPT，都通知主回调
            if (recognitionCompleteListener != null) {
                recognitionCompleteListener.onRecognitionComplete(new ArrayList<>(imageDataList));
            }

        } else {
            Log.w("ImageRecognitionManager", "识别流程结束，但imageDataList为空或null。");
            Toast.makeText(activity, "图像识别流程异常结束。", Toast.LENGTH_SHORT).show();
            if (loadingProgressListener != null) {
                Log.i("onProcessingComplete", "图像识别流程异常结束");
                loadingProgressListener.onProcessingComplete();
            }
            if (recognitionCompleteListener != null) {
                recognitionCompleteListener.onRecognitionComplete(new ArrayList<>());
            }
        }
    }

    private boolean isValidRecognitionResult(String result) {
        return result != null &&
                !result.equals("待识别") && // 初始占位符
                !result.equals("null") &&
                !result.contains("无食物") &&
                !result.contains("没有食物") &&
                !result.contains("非食物") &&
                !result.contains("识别失败"); // 各种失败标记
    }

    // 移除旧的 homeFragment.hideLoadingUI() 和相关逻辑
    // 移除 initializeComponents() 因为相关初始化已在构造函数或使用时进行
    // 移除 triggerPostProcessing() 因为 processAllRecognitionComplete() 中已包含此逻辑
}